#include <iostream>
#include <future>

using namespace std;

int Add(int a, int b)
{
    cout << "加法" << endl;
    return a + b;
}

//三种异步操作


void test1()
{
    // future<int> f1=async(launch::async,Add,10,20);//异步调用Add函数，并将结果放入future对象f1中
    future<int> f2 = async(launch::deferred, Add, 10, 20); // 同步调用Add函数，并将结果放入future对象f2中
    this_thread::sleep_for(chrono::seconds(1));            // 此线程休息1秒
    cout << "--------------------" << endl;
    cout << "Result of Add function is " << f2.get() << endl;
}

void test2()
{
    // 包装函数为可调用对象，改函数可以通过异步调用
    packaged_task<int(int, int)> task(Add);
    // 2.获取future对象
    future<int> f = task.get_future();
    // 3.异步调用包装函数
    packaged_task<int(int, int)> *ptr = &task;
    thread T1([ptr]()
              { (*ptr)(10, 20); }); // 以lamda表达式包装函数，并异步调用，这样的好处是减少了函数参数的传递,减少了构造函数的

    // 异步调用结束后，获取结果

    // 4.获取结果
    cout << "Result of Add function is " << f.get() << endl;
    T1.join();
}



void test3()
{
    // promise和future的使用 promise内部有成员变量future
    promise<int> prom;
    //2.获取future对象
    future<int> f = prom.get_future();
    //3.异步调用
    thread T1([&prom](){
        int m=Add(10,20);
        prom.set_value(m);
    });
    cout<<f.get()<<endl;
    T1.join();
}

int main()
{
    test3();
    return 0;
}